package demo.sicau.votesystem.service.imp;

import demo.sicau.votesystem.constant.DataConstant;
import demo.sicau.votesystem.dao.AdminDao;
import demo.sicau.votesystem.dao.UserDao;
import demo.sicau.votesystem.entity.PO.AdminPO;
import demo.sicau.votesystem.entity.PO.UserPO;
import demo.sicau.votesystem.entity.VO.ResultVO;
import demo.sicau.votesystem.service.UserService;
import demo.sicau.votesystem.util.ResultVOUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.websocket.Session;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


@Service
public class UserServiceImp implements UserService {

    @Autowired
    private UserDao userDao;
    @Autowired
    private AdminDao adminDao;
    @Autowired
    private ResultVOUtil resultVOUtil;

    @Override
    public ResultVO getAllUser() {
        try{
            List<UserPO> userPOList = userDao.selectUsers();
            if(userPOList.size() == 0){
                return resultVOUtil.success("没有用户");
            }else{
                return resultVOUtil.success(userPOList);
            }
        }catch (Exception e){
            e.printStackTrace();
            return resultVOUtil.unknowError();
        }
    }

    @Override
    public ResultVO login(int role,String username, String password, HttpServletRequest request) {
        if ("".equals(username.trim()) && "".equals(password.trim())){
            // 用户传入的用户名密码不能为空字符
            return resultVOUtil.paramError();
        }else {
            try{
                switch (role){
                    case 0:
                        // 执行查询操作，可能抛出异常，所以需要try catch
                        UserPO userPO = userDao.selectUserByPwdAndUsername(username,password);
                        if (userPO == null){
                            // 查不到用户，即用户名密码错误
                            return resultVOUtil.resourceNotFound();
                        }else{
                            // 存放用户凭据
                            HttpSession session = request.getSession();
                            // 存放用户的id到会话session中，第一个参数是键，第二个参数是值
                            session.setAttribute(DataConstant.USER_SESSION_NAME,userPO.getId());
                            // 用户登录成功，返回凭据
                            return resultVOUtil.success("登录成功",userPO.getId());
                        }
                    case 1:
                        AdminPO adminPO = adminDao.selectAdminByPwdAndUsername(username,password);
                        if (adminPO == null){
                            // 查不到用户，即用户名密码错误
                            return resultVOUtil.resourceNotFound();
                        }else{
                            // 存放用户凭据
                            HttpSession session = request.getSession();
                            // 存放用户的id到会话session中，第一个参数是键，第二个参数是值
                            session.setAttribute(DataConstant.ADMIN_SESSION_NAME,adminPO.getId());
                            // 用户登录成功，返回凭据
                            return resultVOUtil.success("登录成功",adminPO.getId());
                        }
                }
                return resultVOUtil.paramError("请传入角色信息");
            }catch (Exception e){
                // 打印异常堆栈信息
                e.printStackTrace();
                // 一旦抛出异常就返回未知错误信息
                return resultVOUtil.unknowError(e.getMessage());
            }
        }
    }

    @Override
    public ResultVO getUser(int page, int limit) {

        /*判断用户是否登录并且拥有权限*/

        // 假设差前10条， limit 0,10
        // 但是现在page = 1 ，limit = 10

        // 假设现在查第二页 page =2 , limit = 10
        // limit 10,10

        try{
            Map<String,Object> resMap = new HashMap<>();
            // 查询数据库总共有多少个用户
            int count = userDao.selectUserCount();
            resMap.put("count",count);
            if(count == 0){
                // 如果数据库中没用用户，就不同进行分页查找
                return resultVOUtil.success(resMap);
            }else{
                // 分页查询用户列表
                List<UserPO> userPOList = userDao.selectUsersByPaging((page - 1) * limit,limit);
                resMap.put("users",userPOList);
                return resultVOUtil.success(resMap);
            }
        }catch (Exception e){
            // 打印出异常堆栈信息
            e.printStackTrace();
            // 返回错误状态，并且返回错误信息
            return resultVOUtil.unknowError(e.getMessage());
        }
    }

    @Override
    public ResultVO deleteUserById(String uid) {
        if("".equals(uid.trim())){
            return resultVOUtil.paramError();
        }else {
            try{
                UserPO userPO = userDao.selectUserById(uid);
                if(userPO == null){
                    return resultVOUtil.resourceNotFound("该用户不存在");
                }else{
                    // 如果不为空表示该用户存在，继续进行删除操作
                    boolean hasDelete = userDao.deleteUserById(uid);
                    if (hasDelete){
                        return resultVOUtil.success();
                    }else{
                        return resultVOUtil.unknowError();
                    }
                }
            }catch (Exception e){
                e.printStackTrace();
                return resultVOUtil.unknowError(e.getMessage());
            }
        }
    }

    @Override
    public ResultVO addUser(UserPO userPO) {
        try{
            // 先查询数据库中是否有这一个username所对应的用户

            boolean hasInsert = userDao.insertUser(userPO);
            if (hasInsert){
                return resultVOUtil.success();
            }else {
                return resultVOUtil.unknowError();
            }
        }catch (Exception e){
            e.printStackTrace();
            return resultVOUtil.unknowError(e.getMessage());
        }
    }

    @Override
    public ResultVO updateUser(UserPO userPO) {
        try{
            // 先查询数据库中是否有这一个username所对应的用户

            // 如果数据库中没有这个用户则不进行修改

            boolean hasInsert = userDao.updateUser(userPO);
            if (hasInsert){
                return resultVOUtil.success();
            }else {
                return resultVOUtil.unknowError();
            }
        }catch (Exception e){
            e.printStackTrace();
            return resultVOUtil.unknowError(e.getMessage());
        }
    }
}
